package services

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"strconv"
	"strings"
)

// 创建代理响应
type CreateProxyResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data json.RawMessage `json:"data"` // 使用RawMessage来处理多种可能的数据类型
}

// 创建代理请求
type CreateProxyRequest struct {
	ProxyType     string `json:"proxy_type"`     // 代理类型：http, socks5, ssh 等
	ProxyIP       string `json:"proxy_ip"`       // 代理IP
	ProxyPort     string `json:"proxy_port"`     // 代理端口
	ProxyUser     string `json:"proxy_user"`     // 代理用户名
	ProxyPassword string `json:"proxy_password"` // 代理密码
	ProxyTagID    string `json:"proxy_tag_id"`   // 代理标签ID
	Note          string `json:"note"`           // 备注
}

// 创建代理
func (api *IxBrowserAPI) CreateProxy(req *CreateProxyRequest) (int, error) {
	url := api.CreateProxyURL
	log.Printf("开始调用CreateProxy API, url: %s", url)

	payloadBytes, err := json.Marshal(req)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return 0, err
	}

	log.Printf("CreateProxy请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return 0, err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return 0, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return 0, err
	}

	log.Printf("响应数据: %s", string(body))

	var response CreateProxyResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return 0, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return 0, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	// 尝试解析data为整数
	var proxyID int
	if err := json.Unmarshal(response.Data, &proxyID); err != nil {
		log.Printf("解析代理ID失败: %v, 原始数据: %s", err, string(response.Data))
		return 0, fmt.Errorf("解析响应数据失败: %v", err)
	}

	log.Printf("成功创建代理，代理ID: %d", proxyID)
	return proxyID, nil
}

// 更新代理请求
type UpdateProxyRequest struct {
	ID            int    `json:"id"`             // 代理ID
	ProxyType     string `json:"proxy_type"`     // 代理类型
	ProxyIP       string `json:"proxy_ip"`       // 代理IP
	ProxyPort     string `json:"proxy_port"`     // 代理端口
	ProxyUser     string `json:"proxy_user"`     // 代理用户名
	ProxyPassword string `json:"proxy_password"` // 代理密码
	ProxyTagID    string `json:"proxy_tag_id"`   // 代理标签ID
	Note          string `json:"note"`           // 备注
}

// 更新代理响应
type UpdateProxyResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data interface{} `json:"data"`
}

// 更新代理
func (api *IxBrowserAPI) UpdateProxy(req *UpdateProxyRequest) error {
	url := api.UpdateProxyURL
	log.Printf("开始调用UpdateProxy API, url: %s", url)

	payloadBytes, err := json.Marshal(req)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return err
	}

	log.Printf("UpdateProxy请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return err
	}

	log.Printf("响应数据: %s", string(body))

	var response UpdateProxyResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	log.Printf("成功更新代理")
	return nil
}

// 删除代理响应
type DeleteProxyResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data interface{} `json:"data"`
}

// 删除代理
func (api *IxBrowserAPI) DeleteProxy(proxyID int) error {
	url := api.DeleteProxyURL
	log.Printf("开始调用DeleteProxy API, url: %s", url)

	payload := map[string]interface{}{
		"id": proxyID,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return err
	}

	log.Printf("DeleteProxy请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return err
	}

	log.Printf("响应数据: %s", string(body))

	var response DeleteProxyResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	log.Printf("成功删除代理")
	return nil
}

// 获取代理列表请求
type GetProxyListRequest struct {
	Page    int    `json:"page"`     // 页码
	Limit   int    `json:"limit"`    // 每页条数
	Type    int    `json:"type"`     // 代理类型
	ProxyIP string `json:"proxy_ip"` // 代理IP
}

// 获取代理列表响应
type GetProxyListResponse struct {
	Error struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Time    int64  `json:"time"`
	} `json:"error"`
	Data struct {
		Total int `json:"total"`
		Items []struct {
			ID            int    `json:"id"`
			ProxyType     string `json:"proxy_type"`
			ProxyIP       string `json:"proxy_ip"`
			ProxyPort     string `json:"proxy_port"`
			ProxyUser     string `json:"proxy_user"`
			ProxyPassword string `json:"proxy_password"`
			ProxyTagID    string `json:"proxy_tag_id"`
			Note          string `json:"note"`
		} `json:"items"`
	} `json:"data"`
}

// 获取代理列表
func (api *IxBrowserAPI) GetProxyList(req *GetProxyListRequest) (*GetProxyListResponse, error) {
	url := api.GetProxyListURL
	log.Printf("开始调用GetProxyList API, url: %s", url)

	payloadBytes, err := json.Marshal(req)
	if err != nil {
		log.Printf("序列化请求数据失败: %v", err)
		return nil, err
	}

	log.Printf("GetProxyList请求数据: %s", string(payloadBytes))

	httpReq, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Printf("创建HTTP请求失败: %v", err)
		return nil, err
	}

	httpReq.Header.Set("Content-Type", "application/json")
	// 添加令牌头
	if api.SecToken != "" {
		httpReq.Header.Set("X-Sec-Token", api.SecToken)
	}
	if api.Token != "" {
		httpReq.Header.Set("X-Token", api.Token)
	}

	log.Printf("发送请求到: %s, 请求头: %v", url, httpReq.Header)

	client := &http.Client{}
	resp, err := client.Do(httpReq)
	if err != nil {
		log.Printf("发送HTTP请求失败: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	log.Printf("收到响应，状态码: %d", resp.StatusCode)

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("读取响应数据失败: %v", err)
		return nil, err
	}

	log.Printf("响应数据: %s", string(body))

	var response GetProxyListResponse
	if err := json.Unmarshal(body, &response); err != nil {
		log.Printf("解析响应数据失败: %v", err)
		return nil, err
	}

	if response.Error.Code != 0 {
		log.Printf("API返回错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
		return nil, fmt.Errorf("API错误: %s (错误码: %d)", response.Error.Message, response.Error.Code)
	}

	log.Printf("成功获取代理列表，总数: %d", response.Data.Total)
	return &response, nil
}

// 解析标签ID字符串为整数数组
func ParseTagIDs(tagIDsStr string) []int {
	if tagIDsStr == "" {
		return []int{}
	}

	parts := strings.Split(tagIDsStr, " ")
	result := make([]int, 0, len(parts))

	for _, part := range parts {
		if id, err := strconv.Atoi(part); err == nil {
			result = append(result, id)
		}
	}

	return result
}

// 将整数数组转换为标签ID字符串
func FormatTagIDs(tagIDs []int) string {
	if len(tagIDs) == 0 {
		return ""
	}

	strs := make([]string, len(tagIDs))
	for i, id := range tagIDs {
		strs[i] = strconv.Itoa(id)
	}

	return strings.Join(strs, " ")
}
